package org.monster.context.core.request;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

/**
 * Http请求装饰
 *
 * @author Monster
 */
public class HttpRequestFacade implements HttpServletRequest {

    private HttpRequest request = null;

    /**
     * @param request 请求
     */
    public HttpRequestFacade(HttpRequest request) {
        this.request = request;
    }

    /**
     * 获取 方法
     *
     * @return 方法
     */
    @Override
    public String getMethod() {
        return request.getMethod();
    }

    /**
     * 获取 请求url
     *
     * @return 请求url
     */
    @Override
    public StringBuffer getRequestURL() {
        return request.getRequestURL();
    }

    /**
     * 获取 请求uri
     *
     * @return 请求uri
     */
    @Override
    public String getRequestURI() {
        return request.getRequestURI();
    }

    /**
     * 获取 协议
     *
     * @return 协议
     */
    @Override
    public String getProtocol() {
        return request.getProtocol();
    }

    /**
     * 获取 头
     *
     * @param name 名称
     * @return 头
     */
    @Override
    public String getHeader(String name) {
        return request.getHeader(name);
    }

    /**
     * 获取参数
     *
     * @param name 名称
     * @return 参数
     */
    @Override
    public String getParameter(String name) {
        return request.getParameter(name);
    }

    /**
     * 获取 请求派遣器
     *
     * @param name 请求派遣器
     * @return 请求派遣器
     */
    @Override
    public RequestDispatcher getRequestDispatcher(String name) {
        return request.getRequestDispatcher(name);
    }

    /**
     * 获取 上下文路径
     *
     * @return 上下文路径
     */
    @Override
    public String getContextPath() {
        return request.getContextPath();
    }

    /**
     * 获取 服务者路径
     *
     * @return 服务者路径
     */
    @Override
    public String getServletPath() {
        return request.getServletPath();
    }

    /**
     * 获取 内容长度
     *
     * @return 内容长度
     */
    @Override
    public int getContentLength() {
        return request.getContentLength();
    }

    /**
     * 获取 服务器端口
     *
     * @return 服务器端口
     */
    @Override
    public int getServerPort() {
        return request.getServerPort();
    }

    /**
     * 获取 派遣器类型
     *
     * @return 派遣器类型
     */
    @Override
    public DispatcherType getDispatcherType() {
        return request.getDispatcherType();
    }

    /**
     * 获取 派遣器类型
     *
     * @return 服务器名
     */
    @Override
    public String getServerName() {
        return request.getServerName();
    }

    /**
     * 获取 字符串编码
     *
     * @return 字符串编码
     */
    @Override
    public String getCharacterEncoding() {
        return request.getCharacterEncoding();
    }

    /**
     * 设置 字符串编码
     *
     * @param characterEncoding 字符串编码
     * @throws UnsupportedEncodingException 不支持编码异常
     */
    @Override
    public void setCharacterEncoding(String characterEncoding)
            throws UnsupportedEncodingException {
        request.setCharacterEncoding(characterEncoding);
    }

    /**
     * 获取 内容类型
     *
     * @return 内容类型
     */
    @Override
    public String getContentType() {
        return request.getContentType();
    }

    /**
     * 获取 属性
     *
     * @param name 名称
     * @return 属性
     */
    @Override
    public Object getAttribute(String name) {
        return getAttribute(name);
    }

    /**
     * 移除 属性
     *
     * @param name 名称
     */
    @Override
    public void removeAttribute(String name) {
        request.removeAttribute(name);
    }

    /**
     * 设置 属性
     *
     * @param name 名称
     * @param obj  对象
     */
    @Override
    public void setAttribute(String name, Object obj) {
        request.setAttribute(name, obj);
    }

    /**
     * 获取 异步上下文
     *
     * @return 异步上下文
     */
    @Override
    public AsyncContext getAsyncContext() {

        return request.getAsyncContext();
    }

    /**
     * 获取 属性名 列举
     *
     * @return 属性名
     */
    @Override
    public Enumeration<String> getAttributeNames() {

        return request.getAttributeNames();
    }

    /**
     * 获取 本地地址
     *
     * @return 本地地址
     */
    @Override
    public String getLocalAddr() {

        return request.getLocalAddr();
    }

    /**
     * 获取 语言环境
     *
     * @return 语言环境
     */
    @Override
    public Locale getLocale() {
        return request.getLocale();
    }

    /**
     * 获取 语言环境 列举
     *
     * @return 语言环境 列举
     */
    @Override
    public Enumeration<Locale> getLocales() {

        return request.getLocales();
    }

    /**
     * 获取 参数 键值
     *
     * @return 参数 键值
     */
    @Override
    public Map<String, String[]> getParameterMap() {

        return request.getParameterMap();
    }

    /**
     * 获取 参数名 键值
     *
     * @return 参数名 键值
     */
    @Override
    public Enumeration<String> getParameterNames() {

        return request.getParameterNames();
    }

    /**
     * 获取 真实路径
     *
     * @param url url
     * @return 真实路径
     */
    @Override
    public String getRealPath(String url) {

        return request.getRealPath(url);
    }

    /**
     * 获取 远程地址
     *
     * @return 远程地址
     */
    @Override
    public String getRemoteAddr() {

        return request.getRemoteAddr();
    }

    /**
     * 获取 模式
     *
     * @return 模式
     */
    @Override
    public String getScheme() {

        return request.getScheme();
    }

    /**
     * 获取 服务者上下文
     *
     * @return 服务者上下文
     */
    @Override
    public ServletContext getServletContext() {

        return request.getServletContext();
    }

    /**
     * 是否 异步开启过
     *
     * @return 布尔
     */
    @Override
    public boolean isAsyncStarted() {

        return request.isAsyncStarted();
    }

    /**
     * 是否 异步支持
     *
     * @return 布尔
     */
    @Override
    public boolean isAsyncSupported() {

        return request.isAsyncSupported();
    }

    /**
     * 是否 安全
     *
     * @return 布尔
     */
    @Override
    public boolean isSecure() {

        return request.isSecure();
    }

    /**
     * 开启 异步
     *
     * @return 异步上下文
     * @throws IllegalStateException 非法状态异常
     */
    @Override
    public AsyncContext startAsync() throws IllegalStateException {

        return request.startAsync();
    }

    /**
     * 开启 异步
     *
     * @param request  请求
     * @param response 响应
     * @return 异步上下文
     * @throws IllegalStateException 非法状态异常
     */
    @Override
    public AsyncContext startAsync(ServletRequest request, ServletResponse response)
            throws IllegalStateException {

        return request.startAsync(request, response);
    }

    /**
     * 授权
     *
     * @param response 响应
     * @return 布尔
     * @throws IOException      输入输出异常
     * @throws ServletException 服务者异常
     */
    @Override
    public boolean authenticate(HttpServletResponse response) throws IOException,
            ServletException {

        return request.authenticate(response);
    }

    /**
     * 获取 授权类型
     *
     * @return 授权类型
     */
    @Override
    public String getAuthType() {

        return request.getAuthType();
    }

    /**
     * 获取 cookie数组
     *
     * @return cookie数组
     */
    @Override
    public Cookie[] getCookies() {

        return request.getCookies();
    }

    /**
     * 获取 日期头
     *
     * @param name 名称
     * @return 时间戳
     */
    @Override
    public long getDateHeader(String name) {

        return request.getDateHeader(name);
    }

    /**
     * 获取 头名称 列举
     *
     * @return 头名称 列举
     */
    @Override
    public Enumeration<String> getHeaderNames() {

        return request.getHeaderNames();
    }

    /**
     * 获取 头 列举
     *
     * @param name 名称
     * @return 头 列举
     */
    @Override
    public Enumeration<String> getHeaders(String name) {

        return request.getHeaders(name);
    }

    /**
     * 获取 初始化头
     *
     * @param name 初始化头
     * @return 初始化头
     */
    @Override
    public int getIntHeader(String name) {

        return request.getIntHeader(name);
    }

    /**
     * 获取 部分
     *
     * @param field 字段
     * @return 部分
     * @throws IOException      输入输出异常
     * @throws ServletException 服务者异常
     */
    @Override
    public Part getPart(String field) throws IOException, ServletException {

        return request.getPart(field);
    }

    /**
     * 获取 部分 集合
     *
     * @return 部分 集合
     * @throws IOException      输入输出异常
     * @throws ServletException 服务者异常
     */
    @Override
    public Collection<Part> getParts() throws IOException, ServletException {

        return request.getParts();
    }

    /**
     * 获取 路径信息
     *
     * @return 路径信息
     */
    @Override
    public String getPathInfo() {

        return request.getPathInfo();
    }

    /**
     * 获取 翻译过路径
     *
     * @return 翻译过路径
     */
    @Override
    public String getPathTranslated() {

        return request.getPathTranslated();
    }

    /**
     * 获取 请求字符串
     *
     * @return 请求字符串
     */
    @Override
    public String getQueryString() {

        return request.getQueryString();
    }

    /**
     * 获取 远程用户
     *
     * @return 远程用户
     */
    @Override
    public String getRemoteUser() {

        return request.getRemoteUser();
    }

    /**
     * 获取 请求会话辨识
     *
     * @return 请求会话辨识
     */
    @Override
    public String getRequestedSessionId() {

        return request.getRequestedSessionId();
    }

    /**
     * 请求 会话
     *
     * @return 会话
     */
    @Override
    public HttpSession getSession() {

        return request.getSession();
    }

    /**
     * 获取 会话
     *
     * @param b 布尔
     * @return 会话
     */
    @Override
    public HttpSession getSession(boolean b) {

        return request.getSession(b);
    }

    /**
     * 获取 首要用户
     *
     * @return 首要用户
     */
    @Override
    public Principal getUserPrincipal() {

        return request.getUserPrincipal();
    }

    /**
     * 是否 来自cookie请求会话辨识
     *
     * @return 布尔
     */
    @Override
    public boolean isRequestedSessionIdFromCookie() {

        return request.isRequestedSessionIdFromCookie();
    }

    /**
     * 是否 来自url请求会话
     *
     * @return 布尔
     */
    @Override
    public boolean isRequestedSessionIdFromURL() {

        return request.isRequestedSessionIdFromURL();
    }

    /**
     * 是否 来自url请求会话
     *
     * @return 布尔
     */
    @Override
    public boolean isRequestedSessionIdFromUrl() {

        return request.isRequestedSessionIdFromUrl();
    }

    /**
     * 是否 请求会话辨识有效
     *
     * @return 布尔
     */
    @Override
    public boolean isRequestedSessionIdValid() {

        return request.isRequestedSessionIdValid();
    }

    /**
     * 是否 用户在角色
     *
     * @param user 用户
     * @return 布尔
     */
    @Override
    public boolean isUserInRole(String user) {

        return request.isUserInRole(user);
    }

    /**
     * 登录
     *
     * @param user     用户
     * @param password 密码
     * @throws ServletException 服务者异常
     */
    @Override
    public void login(String user, String password) throws ServletException {

        request.login(user, password);
    }

    /**
     * 退出
     *
     * @throws ServletException 服务者异常
     */
    @Override
    public void logout() throws ServletException {

        request.logout();
    }

    /**
     * 获取 服务者输入流
     *
     * @return 服务者输入流
     * @throws IOException 输入输出异常
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {

        return request.getInputStream();
    }

    /**
     * 获取 本地名
     *
     * @return 本地名
     */
    @Override
    public String getLocalName() {

        return request.getLocalName();
    }

    /**
     * 获取 本地端口
     *
     * @return 本地端口
     */
    @Override
    public int getLocalPort() {

        return request.getLocalPort();
    }

    /**
     * 获取 参数 数组
     *
     * @param name 名称
     * @return 参数 数组
     */
    @Override
    public String[] getParameterValues(String name) {

        return request.getParameterValues(name);
    }

    /**
     * 获取 缓冲器阅读器
     *
     * @return 缓冲器阅读器
     * @throws IOException 输入输出异常
     */
    @Override
    public BufferedReader getReader() throws IOException {

        return request.getReader();
    }

    /**
     * 获取 远程主机
     *
     * @return 远程主机
     */
    @Override
    public String getRemoteHost() {

        return request.getRemoteHost();
    }

    /**
     * 获取 远程端口
     *
     * @return 远程端口
     */
    @Override
    public int getRemotePort() {

        return request.getRemotePort();
    }
}
